Quality Time - Can Aspect-Oriented Programming Lead to More Reliable Software?

A spect-oriented programming is a novel topic in the software engineering and languages communities. AOP appears to have the potential to significantly improve the reliability of programs, particularly by modu-larizing error-handling policies and allowing for easier maintenance and better reuse. In this article we introduce AspectJ, the first aspect-oriented programming language, and demonstrate how you can use it to construct more reliable software. Modularity in Exception Handling Traditional exception-handling code suffers from many problems, the most prominent being that such code tends not to be very modular. The typical reason for this problem is that programmers treat exception handling as an ad hoc process; programmers often sprinkle handlers carelessly throughout the code and write them on a last-minute, as-needed basis, instead of designing them in from the start. Programmers rarely reuse exception-handling code or apply any abstraction to handlers whatsoever. About the only time programmers apply abstraction to exception handlers is when they employ an exception handler to address multiple types of errors. Unfortunately, handling exceptions generically can result in unreliable and ineffective code. For example, programmers often handle otherwise unanticipated exceptions with catch-all handlers. The problem with this solution is that the programmer often has no idea how to recover gracefully from certain situations. Instead, the programmer creates exceptions that log the problem and then exit instead of recovering dynamically. We are not arguing against generic exceptions. For example, it might be nice to handle all remote method calls that fail using RemoteException by retrying the operation three times before aborting. Unfortunately , such functionality would likely require that the programmer touch many different pieces of code. Ideally, it is better to combine generic exceptions with specialized functionality (programmed on a case-by-case basis for each exception). To do so using traditional exception-writing techniques, programmers must manually change every exception, yielding much duplicate code. Another problem is maintenance of exception-handling code. For example, the intended global nature of exception logging might not be intuitive to those who will someday maintain the code. Future main-tainers might add new exception handlers and forget to add appropriate logging functionality. Crosscutting Concerns The key issue that makes exception handling difficult from a management per